<template>
  <div class="main">
    <!-- 供应商确认表格 -->
    <div class="table">
      <OrderTable
        id="id"
        ref="myTableRef"
        :table-data="tabelOptions.tableData"
        :columns="tabelOptions.colOptionSuppier"
        :active-name="activeName"
        :ischange="true"
        :services-columns="servicesColumns"
        :services-select="servicesSelect"
        :url-data="getUrlData"
        @inputChange="inputChange"
        @rowClick="rowClick"
      />
    </div>
    <!-- 供应商确认按钮 -->
    <div class="btn-config">
      <BtnConfig :btn-configs="saveBtn[isBtnType]" @propClick="handleClick" />
    </div>
  </div>
</template>

<script>
import OrderTable from '../components/OrderTable.vue'
import BtnConfig from '@/components/basic/btnConfig.vue'
import { suppierConfirmBtn, colOptionSuppier, servicesColumns } from '../index.js'
// import suppierFication from './suppierFication.js'
// import VeriFication from '../VeriFication.js'
// const { verificationSuppier } = suppierFication()
// const { filterUpdataTableRow, filteredWithParents } = VeriFication()
import {
    getSuppierConfirmInfo,
    getSuppierConfirmServList,
    getSuppierConfirm,
    updateSuppierSaveInfo
} from '@/api/settlement/balanceSettlement.js'
import {
    getWFWorkItem
} from '@/api/actualBudget/index'
import { Message } from 'element-ui'
export default {
    name: 'SuppierTable',
    components: {
        OrderTable,
        BtnConfig
    },
    props: {
        // 主页面获取到的浏览器地址参数
        getUrlData: {
            type: Object,
            default: () => ({ })
        },
        prjDetails:{
            type: Object,
            default: () => ({ })
        }
    },
    computed:{
        isSoftProject(){
            return this.prjDetails.isNewbusiness === '1' && ['29','25'].includes(this.prjDetails.buildModes) 
        },
    },
    data() {
        return {
            isBtnType: 'A',
            // 服务商人员表头
            servicesColumns,
            // 是服务信息
            activeName: '服务明细信息',
            // 保存明细按钮
            saveBtn: {
                'A': suppierConfirmBtn,
                'B': []
            },
            // 下拉框数据
            servicesSelect: {
                PROVIDERS: [],
                PERSON: []
            },
            // 表格配置
            tabelOptions: {
                // 表头
                colOptionSuppier,
                // 表格数据
                tableData: [],
                provisionalCount: '', // 暂存某个单元格上次的值
                rocordId: []// 保存的时候需要用的id
            },
            // 获取表格信息结算保存需要这三个id很重要
            getObj: {
                adjustId: '',
                serviceCode: '',
                serviceUserId: ''
            }
        }
    },
    created() {
        // 判断当前是那个节点
        this.currentNodeFlow()
    },
    methods: {
        /**
         *
         * @param {*} row 结算确认
         * @param {*} fun
         */
        // 按钮事件 保存明细 /结算确认
        handleClick(row, fun) {
            // 调用保存明细/结算确认方法
            this[row]()
        },
        // 修改表格单元格数据回调
        inputChange(data) {
            this.hanldeinputChange(data)
        },
        // 改变某一行的值需要暂存起来
        rowClick(data) {
            const [, , lastCount] = data
            this.tabelOptions.provisionalCount = lastCount
        },
        // 保存明细按钮
        async saveDetails() {
            // 最终保存的数据
            const data = this.filteredWithParents(this.filterUpdataTableRow(this.tabelOptions.tableData, this.tabelOptions.rocordId, this.activeName))
            // 清空回退意见
            data.forEach(item => {
                if (item.childNodeList) {
                    item.childNodeList.forEach(i => {
                        i.returnInforMation = ''
                    })
                }
            })
            if (data.length > 0) {
                // 需要传一个processInstId
                const { processInstId } = this.getUrlData
                const { code } = await updateSuppierSaveInfo(data, processInstId)
                if (+code === 200) {
                    this.$message({
                        message: '保存成功',
                        type: 'success'
                    })
                    // 获取服务明细信息
                    this.getSuppierTableInfo(this.getObj)
                    this.tabelOptions.rocordId = []
                }
            } else {
                return this.$message({
                    message: '没有改动不需要保存！'
                })
            }
            this.currentNodeFlow()
        },
        // 结算确认按钮
        async settlesConfirm() {
            // 没有点击保存 直接点击结算 需要把保存接口掉一遍
            if (this.tabelOptions.rocordId.length > 0) {
                this.saveDetails()
                this.settlesConfirmMethod()
            } else {
                this.settlesConfirmMethod()
            }
        },
        // 结算确认方法
        async settlesConfirmMethod() {
            // 需要传一个processInstId
            const { processInstId } = this.getUrlData
            const { adjustId, serviceCode, serviceUserId } = this.getObj
            const { code } = await getSuppierConfirm(adjustId, serviceCode, serviceUserId, processInstId)
            if (+code === 200) {
                this.$message({
                    message: '结算成功',
                    type: 'success'
                })
                this.saveBtn = []
                this.currentNodeFlow()
            }
        },
        // 修改单元的数据
        async hanldeinputChange(data) {
            //   校验单元格事件
            this.tabelOptions.rocordId.push(data[2]?.id)
            // 校验单元格
            this.verificationSuppier(data, this.tabelOptions.tableData, this.tabelOptions.provisionalCount)
        },
        // 获取当前是那个节点
        async currentNodeFlow() {
            const { workItemId, type } = this.getUrlData
            if (!workItemId) {
                this.isBtnType = 'B'
                return
            }
            // 从浏览器地址栏获取  判断当前是那个节点
            const { code, data } = await getWFWorkItem({ workItemId: workItemId })

            if (+code === 200) {
                const { bizObject } = data
                // 获取到commonId  后端接口返回从这里面拿到需要的 adjustId serviceCode serviceUserId
                const res = await getSuppierConfirmInfo(bizObject.bizSeq)
                if (type === 'done') {
                    this.isBtnType = 'B'
                }
                if (+res.code === 200 && res.data !== null) {
                    // 拿到需要的id
                    const { adjustId, serviceCode, serviceUserId, noConfirmCount } = res.data
                    // 如果已经结算确认了 则不让按钮显示
                    this.isBtnType = type === 'todo' ? noConfirmCount === '0' ? 'B' : 'A' : 'B'
                    this.getObj.adjustId = adjustId
                    this.getObj.serviceCode = serviceCode
                    this.getObj.serviceUserId = serviceUserId
                    // // 调用表格初始化信息
                    this.getSuppierTableInfo(this.getObj)
                }
            }
        },
        // 获取服务商表格信息
        async getSuppierTableInfo(getObj) {
            const { adjustId, serviceCode, serviceUserId } = getObj
            const { code, data } = await getSuppierConfirmServList(adjustId, serviceCode, serviceUserId)
            if (+code === 200) {
                this.tabelOptions.tableData = data
            }
        },
        // 过滤需要保存的数据
        filterUpdataTableRow(tableData, allIndex, activeName) {
            // 深拷贝一份数据 保存的时候不应该带状态
            const _deepCopy = JSON.parse(JSON.stringify(tableData))
            let _filterData = [] // 初始化定义数组
            if (activeName === '物资明细信息') {
                // 如果是物资则走这个逻辑
                _filterData = _deepCopy.filter((_, index) => allIndex.includes(index))
            } else {
                // 去重数组中重复的id
                const uniqueIndex = allIndex.filter((value, index, self) => {
                    return self.indexOf(value) === index
                })
                // 去重兵器拿到最新的数组
                const result = this.filterNodes(this.uniqueArrId(this.findObjectsByIds(_deepCopy, uniqueIndex)), uniqueIndex)
                // 数组赋值
                _filterData = this.mergeById(_deepCopy, result)
            }
            _filterData.forEach(item => {
                // // 考虑到服务商会存在子节点
                if (item.childNodeList && item.childNodeList.length > 0) {
                    item.childNodeList.forEach(i => {
                        // 删掉id，index
                        delete i.id
                        delete i.index
                    })
                }
                // 删除前端添加的属性
                delete item.id
                delete item.index
            })
            // 返回数组
            return _filterData
        },
        // 服务二次过滤数据
        filterNodes(arr, allId) {
            return arr.map((parentNode) => {
                // 首先map对当前数组的childNodeList进行遍历
                const filteredChildNodes = parentNode.childNodeList.filter(
                    // 查找是否符合条件
                    (childNode) => allId.includes(childNode.id)
                )

                // 检查是否包含任何子节点，或者父节点本身是否在列表中
                const hasIncludedChildOrParent = filteredChildNodes.length > 0 || allId.includes(parentNode.id)
                // 如果存在则返回
                if (hasIncludedChildOrParent) {
                    // 如果不包括子节点，则返回具有筛选的子节点或空数组的父节点
                    return {
                        ...parentNode,
                        childNodeList: filteredChildNodes.length ? filteredChildNodes : []
                    }
                }
                // 如果既不包括父节点也不包括任何子节点，则返回undefined（将从最终结果中过滤掉）
                return undefined
            }).filter(Boolean)
        },
        // 数组去重 id
        uniqueArrId(arr) {
            return arr.reduce((acc, item) => {
                // 如果映射对象中不存在当前 item 的 id，则添加到结果数组和映射对象中
                if (!acc.map.has(item.id)) {
                    acc.result.push(item)
                    acc.map.set(item.id, true)
                }
                return acc
            }, { result: [], map: new Map() }).result
        },
        // 服务需要根据id查找
        findObjectsByIds(arr, targetIds) {
            // 初始化结果数组
            const result = []
            // 遍历输入数组 arr
            for (const obj of arr) {
                // 临时保存当前对象的 children
                const children = obj.childNodeList

                // 如果当前对象有 children 属性，则递归查找其子项
                if (Array.isArray(children)) {
                    const childResults = this.findObjectsByIds(children, targetIds)

                    // 如果在子项中找到了匹配的对象，则将整个子树（包括父对象及其 children）添加到结果数组
                    if (childResults.length > 0) {
                        result.push({
                            ...obj,
                            childNodeList: childResults
                        })
                    }
                }

                // 检查当前对象的 id 是否存在于目标 ID 数组中
                if (targetIds.includes(obj.id)) {
                    // 若存在，则将当前对象添加到结果数组（无需处理 children，因为它们已经包含在子树中）
                    result.push(obj)
                }
            }
            return result
        },
        mergeById(res1, res2) {
            // 遍历对象
            for (const item2 of res2) {
                // 查找符合条件元素
                const existingItemIndex = res1.findIndex(item1 => item1.id === item2.id)
                // 如果-1则没有找到则添加该属性
                if (existingItemIndex !== -1) {
                    res1[existingItemIndex] = item2
                }
            }
            return res1
        },
        // 保存的时候需要按照后端的处理格式 如果父节点变动children 没有变 则把children =[]
        filteredWithParents(res) {
            return res.map((parentItem) => {
                const { childNodeList } = parentItem
                if (childNodeList.every((child) => child.status === '0' || child.status == null)) {
                    // 如果所有的status===0 则将childNodeList=[]
                    return { ...parentItem, childNodeList: [] }
                } else if (childNodeList.every((child) => child.status === '1')) {
                    // 如果status ===1 则将===1的返回
                    return parentItem
                } else {
                    // 如果有status===0 和 status===1 则过滤掉status===0的
                    const filteredChildren = childNodeList.filter((child) => child.status !== '0')
                    return { ...parentItem, childNodeList: filteredChildren }
                }
            })
        },
        messagePromptTitle(message) {
            Message({
                message: message,
                type: 'warning'
            })
        },
        isFloat(n) {
            return parseInt(n) < parseFloat(n)
        },
        verificationSuppier(data, tableData, lastCount) {
            const ifSinglePro = '0'// 是否单项工程项目1时，0否  从 url获取存在就拿不存在给0
            const [item, , row] = data
            // 针对服务需要判断如何调增调减
            const saveEqual = tableData.map(items_ => {
                if (items_.childNodeList && items_.childNodeList.length > 0) {
                    // 只取服务编码 和订单号相同的
                    return items_.childNodeList.filter(_item => (_item.orderNo === row.orderNo && _item.categoryCode === row.categoryCode))
                }
            })
            // 将二维数组转为一维数组
            const toChangeList = saveEqual.flat()
            // 合价不含税累计合价
            const sumTotal = toChangeList.reduce((accumulator, currentObject) => (+accumulator) + (+currentObject.equipSum), 0)
            // 变化合价累计
            const sumChangePriceTotal = toChangeList.reduce((accumulator, currentObject) => (+accumulator) + (+currentObject.changePrice), 0)
            // 判断当前点击那个单元格
            if (item === 'changeNum') {
                this.updateNum(row, tableData, ifSinglePro, lastCount, sumTotal, sumChangePriceTotal)
            } else if (item === 'changePrice') {
                this.updatePrice(row, tableData, ifSinglePro, lastCount, sumTotal, sumChangePriceTotal)
            } else if (item === 'adjustedPrice') {
                this.updateAdjustedPrice(row, tableData, ifSinglePro, lastCount, sumTotal, sumChangePriceTotal)
            } else {
                console.log('stop')
            }
        },
        // 2024-10-10 阻断问题if过多解决方案
        optimizeNewNumOne(numConfig, row) {
            return Number(numConfig) !== 0 && Number(row['precent']) > Number(numConfig)
        },
        optimizeNewNumTwo(doneNum1, ifsb) {
            return this.isFloat(doneNum1) && ifsb !== '0'
        },
        optimizeNewNumThree(doneNum1, special) {
            return doneNum1 < 0 || special
        },
        optimizeNewNumFour(changeNum) {
            return +changeNum === 0 || changeNum === '' || changeNum == null
        },
        optimizeNewNumFive(changeNum, row) {
            return !(changeNum === '' || +row['changeNum'] === 0)
        },
        optimizeNewNumSix(row) {
                let changeStatus = row['changeStatus']
                if (+row['changeNum'] > 0) {
                    changeStatus = '0' // 状态赋值
                } else {
                    changeStatus = '1' // 状态赋值
                }
                return changeStatus
        },
        optimizeNewNumSeven(row) {
            return row['taxRate'] === '' || row['taxRate'] == null
        },
        softNumCalc(row){
            let result = ''
            if(this.isSoftProject||+row['amount']===0){
                result = row['changePrice']
            }else{
                result = (parseFloat(row['donePrice']) - parseFloat(row['equipSum']))
            }
            return result
        },
        softNumCalcTwo(row,doneNum1){
            let result = ''
            if (this.isSoftProject || +row['amount'] === 0) {
                row['changePrice'] = (parseFloat(row['changeNum']) * parseFloat(row['price']))
                result = (+row['equipSum']) + (+row['changePrice'])
            } else {
                result = parseFloat(doneNum1) * parseFloat(row['price'])
            }
            return result
        },
        // 校验数量
        updateNum(row, tableData, ifSinglePro, lastCount, sumTotal, sumChangePriceTotal) {
            const { ifsb, changeNum, amount, scategoryCode, orderProductId, siteId, sourceType, realAmount, percentage, numConfig } = row
            // 如果合价不含税 大于 输入的是负数 并且 累计的变化合价 （绝对值）<= 累计合价不含税（绝对值）提示信息
            const special = sumTotal > 0 && (+row['changeNum']) < 0 && Math.abs(sumChangePriceTotal) > Math.abs(sumTotal)
            // 初始化定义变量
            const doneNum1 = parseFloat(row['changeNum']) + parseFloat(row['amount'])
            // 初始化定义变量
            const proportion = '1'
            // 增调数量是否满足条件
            if (+changeNum === 0) {
                row['changeNum'] = '' // 增调数量赋值
            }
            // 第二个判断
            const percentage01 = percentage + 100
            // 是否满足条件
            if (this.optimizeNewNumOne(numConfig, row)) {
                this.messagePromptTitle(`变化数量”超过原数量的"${numConfig * 100}"%！`)
                row['changeNum'] = 0 // 增调数量赋值
                row['status'] = 0 // 状态赋值
                console.log('updateNum-percentage01', percentage01, proportion)
            } else if (this.optimizeNewNumTwo(doneNum1, ifsb)) {
                // 提示消息
                this.messagePromptTitle(`变化后数量”的计算结果不能为小数！`)
                row['changeNum'] = 0 // 增调数量赋值
                row['status'] = 0 // 状态赋值
            } else if (this.optimizeNewNumThree(doneNum1, special)) {
                this.messagePromptTitle(`累计合价（不含税）金额大于0，调减后的金额需要大于等于0`)
                row['changeNum'] = lastCount || ''// 增调数量赋值
                row['status'] = 0 // 状态赋值
            } else if (this.optimizeNewNumFour(changeNum)) {
                row['status'] = 0 // 状态赋值
                row['doneNum'] = '' // 变化后数量
                row['donePrice'] = '' // 变化后合价
                row['changePrice'] = '' // 变化合价
                row['changeStatus'] = '' // 状态赋值
                row['doneAmt'] = '' // 调整后含税总价
                row['doneTaxAmount'] = '' // 调整后税额
                row['adjustedPrice'] = '' // 单价
            } else if (this.optimizeNewNumFive(changeNum, row)) {
                row['status'] = 1 // 状态赋值
                // 0-调增数量；1-调减数量；2-调增合价；3-调减合价
                row['changeStatus'] = this.optimizeNewNumSix(row)
                // 变化后合价
                row['donePrice'] =this.softNumCalcTwo(row,doneNum1)
                // 合价(不含税)是否满足条件
                if (row['equipSum'] == null) {
                    // 合价(不含税)
                    row['equipSum'] = 0
                }
                // 税率是否满足条件
                if (this.optimizeNewNumSeven(row)) {
                    // 税率赋值
                    row['taxRate'] = 0
                }
                // 变化合价 
                row['changePrice'] = this.softNumCalc(row)
                // 调整后税额
                row['doneTaxAmount'] = parseFloat(row['donePrice']) * parseFloat(row['taxRate'])
                //    调整后含税总价
                row['doneAmt'] = parseFloat(row['donePrice']) + parseFloat(row['doneTaxAmount'])
                // 定义的变量donePrice1
                const donePrice1 = Math.round(row['donePrice'] * 100) / 100
                // 定义的变量changePrice1
                const changePrice1 = Math.round(row['changePrice'] * 100) / 100
                // 计算出来的变化后合价和不含税合价一致还原默认值
                console.log(donePrice1,row['equipSum']);
                
                if (+donePrice1 === (+row['equipSum'])) {
                     this.messagePromptTitle('变化数量的值所填过小，变化合价为0，无法推送商合，请重新填写')
                     this.currentNodeFlow()
                     return
                }
                // 定义的变量doneTaxAmount1
                const doneTaxAmount1 = Math.round(row['doneTaxAmount'] * 100) / 100
                // 定义的变量doneAmt1
                const doneAmt1 = Math.round(row['doneAmt'] * 100) / 100
                row['adjustedPrice'] = '' // 单价赋值
                row['changeNum'] = (+row['changeNum']) // 增调数量赋值
                row['doneNum'] = doneNum1 // 变化后数量
                row['changePrice'] = +changePrice1 // 变化合价
                row['donePrice'] = +donePrice1 // 变化后合价
                row['doneAmt'] = +doneAmt1 // 调整后含税总价
                row['doneTaxAmount'] = +doneTaxAmount1 // 调整后税额
            } else {
                console.log('')
            }
        },
        optimizeNewPriceOne(changePrice) {
            return changePrice == null || changePrice === '' || changePrice === '0' || Math.abs(parseFloat(changePrice)) < 0.005
        },
        optimizeNewPriceTwo(item, scategoryCode, siteId, orderProductId, sourceType) {
            return item.scategoryCode === scategoryCode && item.siteId === siteId && (item.orderProductId !== orderProductId || item.sourceType !== sourceType)
        },
        optimizeNewPriceThree(donePrice1, epcServiceType, ifRoomService, codeBusClassification, master) {
            return donePrice1 === 0 && this.optimizeNewPriceFour(epcServiceType, ifRoomService, codeBusClassification) && master > 0
        },
        optimizeNewPriceFour(epcServiceType, ifRoomService, codeBusClassification) {
            return (epcServiceType === '14' || epcServiceType === '4' || ifRoomService === '1' || codeBusClassification === '14')
        },
        optimizeNewPriceFive(donePrice, row, lastCount) {
                let finishResult = lastCount || ''
                if (donePrice === '' || donePrice == null) {
                    finishResult = '' // 变化合价
                }
                 if (!(donePrice === '' || donePrice == null)) {
                    finishResult = lastCount || row['changePrice'] // 变化合价
                }
                return finishResult
        },
        optimizeNewPriceSix(row, changePrice) {
            return +row['changePrice'] === 0 || changePrice === '' || changePrice == null || Math.abs(parseFloat(changePrice)) < 0.005
        },
        optimizeNewPriceSeven(changePrice, row) {
            return !(changePrice === '' || +row['changePrice'] === 0)
        },
        optimizeNewPriceEight(row) {
            let changeStatus = row['changeStatus']
                if (row['changePrice'] > 0) {
                    changeStatus = '2'
                } else {
                    changeStatus = '3'
                }
                return changeStatus
        },
        optimizeNewPriceNine(row) {
            return row['taxRate'] === '' || row['taxRate'] == null
        },
        optimizeNewPriceTen(row, donePrice1) {
          return (+row['changePrice']) < 0 && donePrice1 === '0'
        },
        optimizeNewPriceEleve(donePrice, row, lastCount) {
            let finishResult = 0
                if (donePrice === '' || donePrice == null) {
                    finishResult = '' // 变化后合价
                }
                 if (!(donePrice === '' || donePrice == null)) {
                    finishResult = lastCount || row['changePrice'] // 变化后合价
                }
                return finishResult
        },
        // 维护改造类2021.11.11 修复阻断
        async optimizeWHupdatePriceOne(row,special) { 
            if (special) {
                this.messagePromptTitle(`累计合价（不含税）金额大于0，调减后的金额需要大于等于0`)
                row['changePrice'] = ''// 变化合价
                row['status'] = 0 // 状态
            }
        },
        async optimizeWHupdatePriceTwo(row,changePrice) { 
            if (this.optimizeNewPriceOne(changePrice)) {
                row['changePrice'] = '' // 变化合价赋值
            }
        },
        async optimizeWHupdatePriceThree(donePrice3) { 
            return donePrice3 === '' || donePrice3 == null
        },
        async optimizeWHupdatePriceFour(row,proportionPrice, equipSum, donePrice2) {
            let backproportionPrice = proportionPrice
            if (parseFloat(donePrice2) > 0) {
                proportionPrice = (Math.abs(donePrice2) / equipSum) * 100
            }
            return backproportionPrice
         },
        async optimizeWHupdatePriceFive(row,donePrice1, epcServiceType, ifRoomService, codeBusClassification, master,donePrice,lastCount) { 
            if (this.optimizeNewPriceThree(donePrice1, epcServiceType, ifRoomService, codeBusClassification, master)) {
                // 提示消息
                this.messagePromptTitle('总包服务、砖混/框架机房服务、外电引入施工服务订单的合价金额不允许调整为0！')
                row['changePrice'] = 0 // 变化后合价
                row['status'] = 0 // 状态
                // 变化后合价逻辑判断
                row['changePrice'] = this.optimizeNewPriceEleve(donePrice, row, lastCount) // 变化后合价
            } 
        },
        async optimizeWHupdatePriceSix(row,donePrice1, lastCount,donePrice) { 
            if (donePrice1 < 0) {
                this.messagePromptTitle('变化后合价”的计算结果不能为负数！')
                row['changePrice'] = lastCount || ''// 变化合价
                row['status'] = 0 // 状态
                row['changePrice'] = this.optimizeNewPriceFive(donePrice, row, lastCount)
            }
        },
        async optimizeWHupdatePriceSeven(row,changePrice) { 
            if (this.optimizeNewPriceSix(row, changePrice)) {
                row['status'] = 0 // 状态
                row['donePrice'] = '' // 变化后合价
                row['changeNum'] = '' // 增调数量
                row['doneNum'] = '' // 变化数量
                row['changeStatus'] = '' // 状态
                row['doneAmt'] = '' // 调整后含税总价
                row['doneTaxAmount'] = '' // 调整后税额
                row['adjustedPrice'] = '' // 单价
            }
        },
        async optimizeWHupdatePriceEight(row,changePrice, donePrice1,percentage01, proportionPrice) { 
            if (this.optimizeNewPriceSeven(changePrice, row)) {
                row['status'] = 1 // 状态
                // 2-调增合价；3-调减合价
                row['changeStatus'] = this.optimizeNewPriceEight(row)
                // 20181217如果变化了合价，变化后数量与变化数量都不变取原来amount
                // doneNum = parseFloat(donePrice1)/parseFloat(price);
                // doneNum = doneNum.toFixed(5);
                // changeNum = parseFloat(doneNum)-parseFloat(amount);
                // 税率是否满足条件
                if (this.optimizeNewPriceNine(row)) {
                    row['taxRate'] = 0 // 税率赋值
                }
                /* 订单金额调增时填写正数，调整数量默认为0
        			订单金额部分调减时填写负数，调整数量默认为0
        			单金额全部调减时填写负数，调整数量默认为订单原始数量的负数 */

                if (this.optimizeNewPriceTen(row, donePrice1)) {
                    row['doneNum'] = '0' // 变化后数量
                    row['changeNum'] = -row['amount'] // 变化数量
                } else {
                    row['doneNum'] = row['amount'] // 变化后数量
                    row['changeNum'] = 0 // 变化数量
                }
                // 调整后税额
                row['doneTaxAmount'] = parseFloat(donePrice1) * parseFloat(row['taxRate'])
                // 调整后含税总价
                row['doneAmt'] = parseFloat(donePrice1) + parseFloat(row['doneTaxAmount'])
                // 初始化定义变量
                const changePrice1 = Math.round(changePrice * 100) / 100
                // 初始化定义变量
                const donPrice2 = Math.round(donePrice1 * 100) / 100
                // 初始化定义变量
                const doneAmt1 = Math.round(row['doneAmt'] * 100) / 100
                // 初始化定义变量
                const doneTaxAmount1 = Math.round(row['doneTaxAmount'] * 100) / 100
                row['adjustedPrice'] = '' // 单价
                row['changePrice'] = +changePrice1 // 变化合价
                row['donePrice'] = +donPrice2 // 变化后合价
                row['doneNum'] = (+row['doneNum']) // 变化数量
                row['changeNum'] = (+row['changeNum']) // 增调数量
                row['doneAmt'] = +doneAmt1 // 调整后含税总价
                row['doneTaxAmount'] = +doneTaxAmount1 // 调整后税额
                console.log(percentage01, proportionPrice, 'updateprice-percentage01-test')
            }
        },
        // 校验合价
      async updatePrice(row, tableData, ifSinglePro, lastCount, sumTotal, sumChangePriceTotal) {
            const { codeBusClassification, master, ifRoomService, changePrice, equipSum, scategoryCode, orderProductId, siteId, sourceType, percentage, epcServiceType, donePrice } = row
            // 如果合价不含税 大于 输入的是负数 并且 累计的变化合价 （绝对值）<= 累计合价不含税（绝对值）提示信息
            const special = sumTotal > 0 && (+row['changePrice']) < 0 && Math.abs(sumChangePriceTotal) > Math.abs(sumTotal)
            await this.optimizeWHupdatePriceOne(row,special)
            // 初始化定义变量
            const donePrice1 = parseFloat(row['changePrice']) + parseFloat(equipSum)
            // 变化合价判断是否满足条件
            await this.optimizeWHupdatePriceTwo(row,changePrice)
            // 初始化定义变量
            let donePrice2 = parseFloat(changePrice) + parseFloat(equipSum)// 该服务订单调整后金额
            // 筛选过滤出相同类型
            const filterTable = tableData.filter(item => {
                if (this.optimizeNewPriceTwo(item, scategoryCode, siteId, orderProductId, sourceType)) {
                    return item
                }
            })
            // for循环对当前table进行遍历循环拿到每一项进行复制
            for (let num = 0; num < filterTable.length; num++) {
                // 不含税合价之和
                row['equipSum'] = equipSum + filterTable[num].equipSum
                // 调整后金额之和
                let donePrice3 = filterTable[num].donePrice // 与该编码相同的服务编码调整后数量
                if (this.optimizeWHupdatePriceThree(donePrice3)) {
                    donePrice3 = filterTable[num].equipSum // 赋值
                }
                // 初始化赋值
                donePrice2 = donePrice2 + parseFloat(donePrice3)
            }
            // 定义初始变量
            let proportionPrice = 0
            // 判断是否满足条件
            proportionPrice = await this.optimizeWHupdatePriceFour(row,proportionPrice, equipSum, donePrice2)
            const percentage01 = percentage + 100
            // 总包服务订单在项目结算调整时，如果该站址总包服务的构成明细中含有主设备物资，那么系统管控当前总包服务订单的合价金额不允许调整为0。
            await this.optimizeWHupdatePriceFive(row,donePrice1, epcServiceType, ifRoomService, codeBusClassification, master,donePrice,lastCount)
            await this.optimizeWHupdatePriceSix(row,donePrice1, lastCount,donePrice)
            await this.optimizeWHupdatePriceSeven(row,changePrice)
            await this.optimizeWHupdatePriceEight(row,changePrice, donePrice1,percentage01, proportionPrice) 
        },
        optimizeNewAdjustedPriceOne(sumTotal, row, sumChangePriceTotal) {
            return sumTotal > 0 && (+row['adjustedPrice']) < 0 && Math.abs(sumChangePriceTotal) > Math.abs(sumTotal)
        },
        optimizeNewAdjustedPriceTwo(row) {
            return row['taxRate'] === '' || row['taxRate'] == null
        },
        
        // 维护改造类2021.11.11 修复阻断
        async optimizeWHupdateAdjustedPriceOne(row,special) { 
            if (special) {
                this.messagePromptTitle(`累计合价（不含税）金额大于0，调减后的金额需要大于等于0`)
                // 单价赋值
                row['adjustedPrice'] = ''
            }
        },
        async optimizeWHupdateAdjustedPriceTwo(row) { 
            if (+row['adjustedPrice'] === 0) {
                row['adjustedPrice'] = '' // 单价赋值
            }
            if(['',null].includes(row['adjustedPrice'])||+row['adjustedPrice']===+row['price']){ 
                //  还原默认值
                row['status'] = 0
                row['changePrice'] = ""
                row['donePrice'] =""
                row['doneNum'] = ""
                row['changeNum'] = ""
                row['doneAmt'] = ""
                row['doneTaxAmount'] = ""
                row['changeStatus'] = ""
                row['taxRate'] = ""
                throw ''
            }
        },
        async optimizeWHupdateAdjustedPriceThree(row,donePrice1,lastCount,_copyrow) {
            if (donePrice1 < 0) {
                this.messagePromptTitle('调整后合价”的计算结果不能为负数！')
                // 单价赋值
                row['adjustedPrice'] = lastCount || ''
            } else {
                await this.optimizeWHupdateAdjustedPriceFour(row)
                row['changePrice'] = donePrice1 - row['equipSum'] // 变化合价
                row['status'] = 1 // 状态
                // 4-调增单价；5-调减单价
                await this.optimizeWHupdateAdjustedPriceFive(row)
                 if (+row['changePrice'] === 0) {
                    // 当变化合价为0时 还原默认值
                    row['changePrice'] = _copyrow.changePrice
                    row['donePrice'] = _copyrow.donePrice
                    row['doneNum'] = _copyrow.doneNum
                    row['changeNum'] = _copyrow.changeNum
                    row['doneAmt'] = _copyrow.doneAmt
                    row['doneTaxAmount'] = _copyrow.doneTaxAmount
                    return Promise.reject()
                }
                // 税率是否满足条件
                if (this.optimizeNewAdjustedPriceTwo(row)) {
                    row['taxRate'] = 0 // 税率赋值
                }
                /* 订单金额调增时填写正数，调整数量默认为0，调整后数量为原数量
        						         订单金额部分调减时填写负数，调整数量默认为0，调整后数量为原数量
        						         订单金额全部调减时填写负数，调整数量默认为订单原始数量的负数 */
                await this.optimizeWHupdateAdjustedPriceSix(row,donePrice1)
                // // 调整后税额
                row['doneTaxAmount'] = parseFloat(donePrice1) * parseFloat(row['taxRate'])
                //  // 调整后含税总价
                row['doneAmt'] = parseFloat(donePrice1) + parseFloat(row['doneTaxAmount'])
                // 初始化定义变量
                const changePrice1 = Math.round(+row['changePrice'] * 100) / 100
                // 初始化定义变量
                const donPrice2 = Math.round(donePrice1 * 100) / 100
                // 初始化定义变量
                const doneAmt1 = Math.round(row['doneAmt'] * 100) / 100
                // 初始化定义变量
                const doneTaxAmount1 = Math.round(row['doneTaxAmount'] * 100) / 100
                row['changePrice'] = +changePrice1 === 0 ? '' : (+changePrice1) // // 变化合价
                row['donePrice'] = +donPrice2 // 变化后合价
                row['doneNum'] = (+row['doneNum']) // 变化数量
                row['changeNum'] = (+row['changeNum']) === 0 ? '' : (+row['changeNum']) // 增调数量
                row['doneAmt'] = +doneAmt1 // 调整后含税总价
                row['doneTaxAmount'] = +doneTaxAmount1 // 调整后税额
            }
         },
        async optimizeWHupdateAdjustedPriceFour(row) {
            if (Math.abs(parseFloat(row['adjustedPrice'])) < 0.005) {
                row['adjustedPrice'] = 0 // 单价赋值
            }
         },
        async optimizeWHupdateAdjustedPriceFive(row) {
            if (+row['changePrice'] > 0) {
                row['changeStatus'] = '4'
            }
            if (+row['changePrice'] < 0) {
                row['changeStatus'] = '5'
            }
         },
         async optimizeWHupdateAdjustedPriceSix(row,donePrice1) {
            if (row['changePrice'] < 0 && donePrice1 === '0') {
                row['doneNum'] = '0' // 变化后数量
                row['changeNum'] = 0 // 变化数量-row['amount']
            } else {
                row['doneNum'] = row['amount'] // 变化后数量
                row['changeNum'] = 0 // 变化数量
            }
         },
        // 调整后单价编辑完成后触发函数
      async  updateAdjustedPrice(row, tableData, ifSinglePro, lastCount, sumTotal, sumChangePriceTotal) {
            // 深拷贝一份 当changePrice =0 还原默认值
            const _copyrow = JSON.parse(JSON.stringify(row))
            const { adjustedPrice, amount, changePrice, equipSum, percentage, scategoryCode, siteId, orderProductId, sourceType } = row
            // 如果合价不含税 大于 输入的是负数 并且 累计的变化合价 （绝对值）<= 累计合价不含税（绝对值）提示信息
            const special = this.optimizeNewAdjustedPriceOne(sumTotal, row, sumChangePriceTotal)
            await this.optimizeWHupdateAdjustedPriceOne(row,special)
            const donePrice1 = parseFloat((+adjustedPrice)) * parseFloat((+amount))// 调整后金额 = 调整后单价 * 数量
            const donePrice2 = parseFloat((+adjustedPrice)) * parseFloat((+amount))// 该服务订单调整后金额
            const proportionPrice = 0 // 初始化定义变量
            const percentage01 = 0 // 初始化定义变量
            // 单价是否满足条件
            await this.optimizeWHupdateAdjustedPriceTwo(row)
            console.log(donePrice2, proportionPrice, percentage01)
            // 二次判断
            await this.optimizeWHupdateAdjustedPriceThree(row,donePrice1,lastCount,_copyrow)
        }
    }
}
</script>
<style lang="scss" scoped>
.main {
    margin-top: 35px;
}

::v-deep .el-icon-arrow-right:before {
    content: "\e6e0" !important;
}

.btn-config {
    display: flex;
    justify-content: center;
    margin-top: 15px
}

.btn-config ::v-deep .btnBox {
    display: block;
}

::v-deep .el-table__row td:nth-child(3) .cell .header-tooltip {
    width: 160px;
}
</style>
